"
<html>
<head></head>
<body><a name=\"ZH-CN_TOPIC_0000002313462733\"></a><a name=\"ZH-CN_TOPIC_0000002313462733\"></a>
<h1>TaskPool简介</h1>
<div><p>TaskPool为应用程序提供多线程环境，降低资源消耗、提高系统性能，无需管理线程生命周期。具体接口信息及使用方法详情请见<a
        href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-taskpool\" target=\"_blank\">TaskPool</a>。
</p>
    <div class=\"section\" id=\"taskpool运作机制\"><a
            name=\"ZH-CN_TOPIC_0000002313462733__taskpool%E8%BF%90%E4%BD%9C%E6%9C%BA%E5%88%B6\"></a><a
            name=\"taskpool%E8%BF%90%E4%BD%9C%E6%9C%BA%E5%88%B6\"></a>     <h4>TaskPool运作机制</h4>
        <p>TaskPool运作机制示意图</p>
        <p><span><img originheight=\"535\" originwidth=\"800\"
                      src=\"https://communityfile-drcn.op.dbankcloud.cn/FileServer/getFile/cmtyPub/011/111/111/0000000000011111111.20250704161535.36038672880192492009303616875685:50001231000000:2800:8FC0ACFCAF9085EF755703894A560BBD973A9EC89F3176356D90B77C22B84EF0.png\"></span>
        </p>
        <p>
            TaskPool支持开发者在宿主线程提交任务到任务队列，系统选择合适的工作线程执行任务，再将结果返回给宿主线程。接口易用，支持任务执行、取消和指定优先级，同时通过系统统一线程管理，结合动态调度及负载均衡算法，可以节约系统资源。系统默认启动一个任务工作线程，任务多时会扩容。工作线程数量上限取决于设备的物理核数，内部管理具体数量，确保调度和执行效率最优。长时间无任务分发时会缩容，减少工作线程数量。具体扩缩容机制详情请见<a
                href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/taskpool-introduction#taskpool扩缩容机制\">TaskPool扩缩容机制</a>。
        </p></div>
    <div class=\"section\" id=\"taskpool注意事项\"><a
            name=\"ZH-CN_TOPIC_0000002313462733__taskpool%E6%B3%A8%E6%84%8F%E4%BA%8B%E9%A1%B9\"></a><a
            name=\"taskpool%E6%B3%A8%E6%84%8F%E4%BA%8B%E9%A1%B9\"></a>     <h4>TaskPool注意事项</h4>
        <ul>
            <li><p>实现任务的函数需要使用<a href=\"#concurrent装饰器\">@Concurrent装饰器</a>标注，且仅支持在.ets文件中使用。
            </p></li>
            <li><p>从API version 11开始，跨并发实例传递带方法的实例对象时，该类必须使用装饰器<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-sendable#sendable装饰器\">@Sendable装饰器</a>标注，且仅支持在.ets文件中使用。
            </p></li>
            <li><p>任务函数（<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-taskpool#longtask12\"
                    target=\"_blank\">LongTask</a>除外）在TaskPool工作线程的执行耗时不能超过3分钟（不包含Promise和async/await异步调用的耗时，例如网络下载、文件读写等I/O任务的耗时）。否则，任务将被强制终止。
            </p></li>
            <li><p>实现任务的函数入参需满足序列化支持的类型，详情请参见<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/interthread-communication-overview\">线程间通信对象</a>。目前不支持使用<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-state\">@State装饰器</a>、<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-prop\">@Prop装饰器</a>、<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-link\">@Link装饰器</a>等装饰器修饰的复杂类型。
            </p></li>
            <li><p>ArrayBuffer参数在TaskPool中默认转移，需要设置转移列表的话可通过接口<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-taskpool#settransferlist10\"
                    target=\"_blank\">setTransferList()</a>设置。如果需要多次调用使用ArrayBuffer作为参数的task，则需要通过接口<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-taskpool#setclonelist11\"
                    target=\"_blank\">setCloneList()</a>把ArrayBuffer在线程中的传输行为改成拷贝传递，避免对原有对象产生影响。
            </p>
                <pre class=\"ts\">import { taskpool } from '@kit.ArkTS';\nimport { BusinessError } from '@kit.BasicServicesKit';\n\n@Concurrent\nfunction printArrayBuffer(buffer: ArrayBuffer) {\n  return buffer;\n}\n\nfunction testArrayBuffer() {\n  const buffer = new ArrayBuffer(1);\n  const group = new taskpool.TaskGroup();\n  const task = new taskpool.Task(printArrayBuffer, buffer);\n  group.addTask(task);\n  task.setCloneList([buffer]);\n  for (let i = 0; i &lt; 5; i++) {\n    taskpool.execute(group).then(() =&gt; {\n      console.info('execute group success');\n    }).catch((e: BusinessError) =&gt; {\n      console.error(`execute group error: ${e.message}`);\n    })\n  }\n}</pre>
            </li>
            <li><p>
                由于不同线程中上下文对象是不同的，因此TaskPool工作线程只能使用线程安全的库，例如UI相关的非线程安全库不能使用。</p>
            </li>
            <li><p>序列化传输的数据量限制为16MB。</p></li>
            <li><p><a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-taskpool#priority\"
                    target=\"_blank\">Priority</a>的IDLE优先级是用来标记需要在后台运行的耗时任务（例如数据同步、备份），它的优先级别是最低的。这种优先级的任务只在所有线程都空闲时触发执行，并且同一时间只会有一个IDLE优先级的任务执行。
            </p></li>
            <li><p>
                Promise不支持跨线程传递。TaskPool返回pending或rejected状态的Promise时会失败，返回fulfilled状态的Promise时TaskPool会解析返回的结果，如果结果可以跨线程传递，则返回成功。</p>
            </li>
            <li><p>不支持在TaskPool工作线程中使用<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/arkts-appstorage\">AppStorage</a>。
            </p></li>
            <li><p>
                TaskPool支持开发者在宿主线程封装任务并提交给任务队列，理论上支持的任务数量没有上限。然而，任务的执行效率受限于任务的优先级和系统资源。当工作线程达到最大数量时，任务的执行效率可能会下降。</p>
            </li>
            <li><p>TaskPool不支持指定任务所运行的线程，任务会被分配到空闲的线程中执行。如果需要指定任务所运行的线程，建议使用<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/worker-introduction\">Worker</a>。
            </p></li>
        </ul>
    </div>
    <div class=\"section\" id=\"concurrent装饰器\"><a
            name=\"ZH-CN_TOPIC_0000002313462733__concurrent%E8%A3%85%E9%A5%B0%E5%99%A8\"></a><a
            name=\"concurrent%E8%A3%85%E9%A5%B0%E5%99%A8\"></a>     <h4>@Concurrent装饰器</h4>
        <p>在使用<a href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-taskpool\"
                    target=\"_blank\">TaskPool</a>时，执行的并发函数需要使用该装饰器修饰，否则无法通过相关校验。</p>
        <div class=\"note\"><img originheight=\"38\" originwidth=\"102\"
                                 src=\"https://communityfile-drcn.op.dbankcloud.cn/FileServer/getFile/cmtyPub/011/111/111/0000000000011111111.20250704161535.72221736236265479024350859162317:50001231000000:2800:E37AAC8FB11C68494D2E145E970E88472794167BE5BA2C9DE85138A36E067969.png\"><span
                class=\"notetitle\"> </span>
            <div class=\"notebody\"><p>从API version 9开始，支持使用@Concurrent装饰器声明并校验并发函数。</p></div>
        </div>
    </div>
    <div class=\"section\" id=\"装饰器说明\"><a
            name=\"ZH-CN_TOPIC_0000002313462733__%E8%A3%85%E9%A5%B0%E5%99%A8%E8%AF%B4%E6%98%8E\"></a><a
            name=\"%E8%A3%85%E9%A5%B0%E5%99%A8%E8%AF%B4%E6%98%8E\"></a>     <h4>[h2]装饰器说明</h4>
        <div class=\"tablenoborder\">
            <table>
                <thead>
                <tr>
                    <th align=\"left\" class=\"cellrowborder\" id=\"mcps1.3.5.2.1.3.1.1\" valign=\"top\" width=\"50%\">
                        @Concurrent并发装饰器
                    </th>
                    <th align=\"left\" class=\"cellrowborder\" id=\"mcps1.3.5.2.1.3.1.2\" valign=\"top\" width=\"50%\">
                        说明
                    </th>
                </tr>
                </thead>
                <tbody>
                <tr>
                    <td class=\"cellrowborder\" valign=\"top\" width=\"50%\">装饰器参数</td>
                    <td class=\"cellrowborder\" valign=\"top\" width=\"50%\">无。</td>
                </tr>
                <tr>
                    <td class=\"cellrowborder\" valign=\"top\" width=\"50%\">使用场景</td>
                    <td class=\"cellrowborder\" valign=\"top\" width=\"50%\">
                        仅支持在Stage模型的工程中使用。仅支持在.ets文件中使用。
                    </td>
                </tr>
                <tr>
                    <td class=\"cellrowborder\" valign=\"top\" width=\"50%\">装饰的函数类型</td>
                    <td class=\"cellrowborder\" valign=\"top\" width=\"50%\">
                        允许标注async函数或普通函数。禁止标注generator、箭头函数、类方法。不支持类成员函数或者匿名函数。
                    </td>
                </tr>
                <tr>
                    <td class=\"cellrowborder\" valign=\"top\" width=\"50%\">装饰的函数内的变量类型</td>
                    <td class=\"cellrowborder\" valign=\"top\" width=\"50%\">
                        允许使用local变量、入参和通过import引入的变量。禁止使用闭包变量。
                    </td>
                </tr>
                <tr>
                    <td class=\"cellrowborder\" valign=\"top\" width=\"50%\">装饰的函数内的返回值类型</td>
                    <td class=\"cellrowborder\" valign=\"top\" width=\"50%\">支持的类型请查<a
                            href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/interthread-communication-overview\">线程间通信对象</a>。
                    </td>
                </tr>
                </tbody>
            </table>
        </div>
        <div class=\"note\"><img originheight=\"38\" originwidth=\"102\"
                                 src=\"https://communityfile-drcn.op.dbankcloud.cn/FileServer/getFile/cmtyPub/011/111/111/0000000000011111111.20250704161535.25170299189518904671373787184139:50001231000000:2800:FCDEFDCC56F1B1CFD81A2CF56D99B4A39CDF44F985C3792A4EF16BE20405635E.png\"><span
                class=\"notetitle\"> </span>
            <div class=\"notebody\"><p>
                由于@Concurrent标记的函数不能访问闭包，因此函数内部不能调用当前文件的其他函数，例如：</p>
                <pre class=\"ts\">function bar() {\n}\n\n@Concurrent\nfunction foo() {\n  bar(); // 违反闭包原则，报错\n}</pre>
            </div>
        </div>
    </div>
    <div class=\"section\" id=\"装饰器使用示例\"><a
            name=\"ZH-CN_TOPIC_0000002313462733__%E8%A3%85%E9%A5%B0%E5%99%A8%E4%BD%BF%E7%94%A8%E7%A4%BA%E4%BE%8B\"></a><a
            name=\"%E8%A3%85%E9%A5%B0%E5%99%A8%E4%BD%BF%E7%94%A8%E7%A4%BA%E4%BE%8B\"></a>     <h4>
        [h2]装饰器使用示例</h4></div>
    <p><strong>并发函数一般使用</strong></p>
    <p>并发函数为一个计算两数之和的普通函数，taskpool执行该函数并返回结果。</p>
    <p>示例：</p>
    <pre class=\"ts\">import { taskpool } from '@kit.ArkTS';\n\n@Concurrent\nfunction add(num1: number, num2: number): number {\n  return num1 + num2;\n}\n\nasync function concurrentFunc(): Promise&lt;void&gt; {\n  try {\n    const task: taskpool.Task = new taskpool.Task(add, 1, 2);\n    console.info(`taskpool res is: ${await taskpool.execute(task)}`); // 输出结果：taskpool res is: 3\n  } catch (e) {\n    console.error(`taskpool execute error is: ${e}}`);\n  }\n}\n\n@Entry\n@Component\nstruct Index {\n  @State message: string = 'Hello World';\n\n  build() {\n    Row() {\n      Column() {\n        Text(this.message)\n          .fontSize(50)\n          .fontWeight(FontWeight.Bold)\n          .onClick(() =&gt; {\n            concurrentFunc();\n          })\n      }\n      .width('100%')\n    }\n    .height('100%')\n  }\n}</pre>
    <p><strong>并发函数返回Promise</strong></p>
    <p>并发函数中返回Promise时需要特别关注。如示例所示，testPromise和testPromise1等需处理Promise并返回结果。</p>
    <p>示例：</p>
    <pre class=\"ts\">import { taskpool } from '@kit.ArkTS';\n\n@Concurrent\nfunction testPromise(args1: number, args2: number): Promise&lt;number&gt; {\n  return new Promise&lt;number&gt;((resolve, reject) =&gt; {\n    resolve(args1 + args2);\n  });\n}\n\n@Concurrent\nasync function testPromise1(args1: number, args2: number): Promise&lt;number&gt; {\n  return new Promise&lt;number&gt;((resolve, reject) =&gt; {\n    resolve(args1 + args2);\n  });\n}\n\n@Concurrent\nasync function testPromise2(args1: number, args2: number): Promise&lt;number&gt; {\n  return await new Promise&lt;number&gt;((resolve, reject) =&gt; {\n    resolve(args1 + args2);\n  });\n}\n\n@Concurrent\nfunction testPromise3() {\n  return Promise.resolve(1);\n}\n\n@Concurrent\nasync function testPromise4(): Promise&lt;number&gt; {\n  return 1;\n}\n\n@Concurrent\nasync function testPromise5(): Promise&lt;string&gt; {\n  return await new Promise((resolve) =&gt; {\n    setTimeout(() =&gt; {\n      resolve('Promise setTimeout after resolve');\n    }, 1000)\n  });\n}\n\nasync function testConcurrentFunc() {\n  const task1: taskpool.Task = new taskpool.Task(testPromise, 1, 2);\n  const task2: taskpool.Task = new taskpool.Task(testPromise1, 1, 2);\n  const task3: taskpool.Task = new taskpool.Task(testPromise2, 1, 2);\n  const task4: taskpool.Task = new taskpool.Task(testPromise3);\n  const task5: taskpool.Task = new taskpool.Task(testPromise4);\n  const task6: taskpool.Task = new taskpool.Task(testPromise5);\n\n  taskpool.execute(task1).then((d: object) =&gt; {\n    console.info(`task1 res is: ${d}`); // 输出结果：task1 res is: 3\n  }).catch((e: object) =&gt; {\n    console.error(`task1 catch e: ${e}`);\n  })\n  taskpool.execute(task2).then((d: object) =&gt; {\n    console.info(`task2 res is: ${d}`);\n  }).catch((e: object) =&gt; {\n    console.error(`task2 catch e: ${e}`); // 输出结果：task2 catch e: Error: Can't return Promise in pending state\n  })\n  taskpool.execute(task3).then((d: object) =&gt; {\n    console.info(`task3 res is: ${d}`); // 输出结果：task3 res is: 3\n  }).catch((e: object) =&gt; {\n    console.error(`task3 catch e: ${e}`);\n  })\n  taskpool.execute(task4).then((d: object) =&gt; {\n    console.info(`task4 res is: ${d}`); // 输出结果：task4 res is: 1\n  }).catch((e: object) =&gt; {\n    console.error(`task4 catch e: ${e}`);\n  })\n  taskpool.execute(task5).then((d: object) =&gt; {\n    console.info(`task5 res is: ${d}`); // 输出结果：task5 res is: 1\n  }).catch((e: object) =&gt; {\n    console.error(`task5 catch e: ${e}`);\n  })\n  taskpool.execute(task6).then((d: object) =&gt; {\n    console.info(`task6 res is: ${d}`); // 输出结果：task6 res is: Promise setTimeout after resolve\n  }).catch((e: object) =&gt; {\n    console.error(`task6 catch e: ${e}`);\n  })\n}\n\n@Entry\n@Component\nstruct Index {\n  @State message: string = 'Hello World';\n\n  build() {\n    Row() {\n      Column() {\n        Button(this.message)\n          .fontSize(50)\n          .fontWeight(FontWeight.Bold)\n          .onClick(() =&gt; {\n            testConcurrentFunc();\n          })\n      }\n      .width('100%')\n    }\n    .height('100%')\n  }\n}</pre>
    <p><strong>并发函数中使用自定义类或函数</strong></p>
    <p>在并发函数中使用自定义类或函数时，需将其定义在不同的文件中，否则会被认为是闭包。如以下示例所示。</p>
    <p>示例：</p>
    <pre class=\"ts\">// Index.ets\nimport { taskpool } from '@kit.ArkTS';\nimport { BusinessError } from '@kit.BasicServicesKit';\nimport { testAdd, MyTestA, MyTestB } from './Test';\n\nfunction add(arg: number) {\n  return ++arg;\n}\n\nclass TestA {\n  constructor(name: string) {\n    this.name = name;\n  }\n\n  name: string = 'ClassA';\n}\n\nclass TestB {\n  static nameStr: string = 'ClassB';\n}\n\n@Concurrent\nfunction TestFunc() {\n  // case1：在并发函数中直接调用同文件内定义的类或函数\n\n  // 直接调用同文件定义的函数add()，add飘红报错：Only imported variables and local variables can be used in @Concurrent decorated functions. &lt;ArkTSCheck&gt;\n  // add(1);\n  // 直接使用同文件定义的TestA构造，TestA飘红报错：Only imported variables and local variables can be used in @Concurrent decorated functions. &lt;ArkTSCheck&gt;\n  // const a = new TestA('aaa');\n  // 直接访问同文件定义的TestB的成员nameStr，TestB飘红报错：Only imported variables and local variables can be used in @Concurrent decorated functions. &lt;ArkTSCheck&gt;\n  // console.info(`TestB name is: ${TestB.nameStr}`);\n\n  // case2：在并发函数中调用定义在Test.ets文件并导入当前文件的类或函数\n\n  // 输出结果：res1 is: 2\n  console.info(`res1 is: ${testAdd(1)}`);\n  const tmpStr = new MyTestA('TEST A');\n  // 输出结果：res2 is: TEST A\n  console.info(`res2 is: ${tmpStr.name}`);\n  // 输出结果：res3 is: MyTestB\n  console.info(`res3 is: ${MyTestB.nameStr}`);\n}\n\n\n@Entry\n@Component\nstruct Index {\n  @State message: string = 'Hello World';\n\n  build() {\n    RelativeContainer() {\n      Text(this.message)\n        .id('HelloWorld')\n        .fontSize(50)\n        .fontWeight(FontWeight.Bold)\n        .alignRules({\n          center: { anchor: '__container__', align: VerticalAlign.Center },\n          middle: { anchor: '__container__', align: HorizontalAlign.Center }\n        })\n        .onClick(() =&gt; {\n          const task = new taskpool.Task(TestFunc);\n          taskpool.execute(task).then(() =&gt; {\n            console.info('taskpool: execute task success!');\n          }).catch((e: BusinessError) =&gt; {\n            console.error(`taskpool: execute: Code: ${e.code}, message: ${e.message}`);\n          })\n        })\n    }\n    .height('100%')\n    .width('100%')\n  }\n}</pre>
    <pre class=\"ts\">// Test.ets\nexport function testAdd(arg: number) {\n  return ++arg;\n}\n\n@Sendable\nexport class MyTestA {\n  constructor(name: string) {\n    this.name = name;\n  }\n  name: string = 'MyTestA';\n}\n\nexport class MyTestB {\n  static nameStr:string = 'MyTestB';\n}</pre>
    <p><strong>并发异步函数中使用Promise</strong></p>
    <p>在并发异步函数中使用Promise时，建议搭配await使用。这样TaskPool可以捕获Promise中的异常。推荐使用示例如下。</p>
    <p>示例：</p>
    <pre class=\"ts\">import { taskpool } from '@kit.ArkTS';\n\n@Concurrent\nasync function testPromiseError() {\n  await new Promise&lt;number&gt;((resolve, reject) =&gt; {\n    resolve(1);\n  }).then(() =&gt; {\n    throw new Error('testPromise Error');\n  })\n}\n\n@Concurrent\nasync function testPromiseError1() {\n  await new Promise&lt;string&gt;((resolve, reject) =&gt; {\n    reject('testPromiseError1 Error msg');\n  })\n}\n\n@Concurrent\nfunction testPromiseError2() {\n  return new Promise&lt;string&gt;((resolve, reject) =&gt; {\n    reject('testPromiseError2 Error msg');\n  })\n}\n\nasync function testConcurrentFunc() {\n  const task1: taskpool.Task = new taskpool.Task(testPromiseError);\n  const task2: taskpool.Task = new taskpool.Task(testPromiseError1);\n  const task3: taskpool.Task = new taskpool.Task(testPromiseError2);\n\n  taskpool.execute(task1).then((d: object) =&gt; {\n    console.info(`task1 res is: ${d}`);\n  }).catch((e: object) =&gt; {\n    console.error(`task1 catch e: ${e}`); // task1 catch e: Error: testPromise Error\n  })\n  taskpool.execute(task2).then((d: object) =&gt; {\n    console.info(`task2 res is: ${d}`);\n  }).catch((e: object) =&gt; {\n    console.error(`task2 catch e: ${e}`); // task2 catch e: testPromiseError1 Error msg\n  })\n  taskpool.execute(task3).then((d: object) =&gt; {\n    console.info(`task3 res is: ${d}`);\n  }).catch((e: object) =&gt; {\n    console.error(`task3 catch e: ${e}`); // task3 catch e: testPromiseError2 Error msg\n  })\n}\n\n@Entry\n@Component\nstruct Index {\n  @State message: string = 'Hello World';\n\n  build() {\n    Row() {\n      Column() {\n        Button(this.message)\n          .fontSize(50)\n          .fontWeight(FontWeight.Bold)\n          .onClick(() =&gt; {\n            testConcurrentFunc();\n          })\n      }\n      .width('100%')\n    }\n    .height('100%')\n  }\n}</pre>
    <div class=\"section\" id=\"taskpool扩缩容机制\"><a
            name=\"ZH-CN_TOPIC_0000002313462733__taskpool%E6%89%A9%E7%BC%A9%E5%AE%B9%E6%9C%BA%E5%88%B6\"></a><a
            name=\"taskpool%E6%89%A9%E7%BC%A9%E5%AE%B9%E6%9C%BA%E5%88%B6\"></a>     <h4>TaskPool扩缩容机制</h4></div>
    <div class=\"section\" id=\"扩容机制\"><a
            name=\"ZH-CN_TOPIC_0000002313462733__%E6%89%A9%E5%AE%B9%E6%9C%BA%E5%88%B6\"></a><a
            name=\"%E6%89%A9%E5%AE%B9%E6%9C%BA%E5%88%B6\"></a>     <h4>[h2]扩容机制</h4>
        <p>
            一般情况下，开发者向任务队列提交任务时会触发扩容检测。扩容检测首先判断当前空闲的工作线程数是否大于任务数，如果大于，说明线程池中存在空闲工作线程，无需扩容。否则，通过负载计算确定所需工作线程数并创建。</p>
    </div>
    <div class=\"section\" id=\"缩容机制\"><a
            name=\"ZH-CN_TOPIC_0000002313462733__%E7%BC%A9%E5%AE%B9%E6%9C%BA%E5%88%B6\"></a><a
            name=\"%E7%BC%A9%E5%AE%B9%E6%9C%BA%E5%88%B6\"></a>     <h4>[h2]缩容机制</h4>
        <p>
            扩容后，TaskPool新建多个工作线程，但当任务数减少后，这些线程就会处于空闲状态，造成资源浪费，因此TaskPool提供缩容机制。TaskPool使用了定时器，定时检测当前负载。定时器30s触发一次，每次尝试释放空闲的工作线程。释放的线程需要满足如下条件：</p>
        <ul>
            <li><p>该线程空闲时长达到30s。</p></li>
            <li><p>该线程上未执行长时任务（<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-taskpool#longtask12\"
                    target=\"_blank\">LongTask</a>）。</p></li>
            <li><p>该线程上没有业务申请且未释放的句柄，例如<a
                    href=\"https://developer.huawei.com/consumer/cn/doc/harmonyos-references/js-apis-timer\"
                    target=\"_blank\">Timer(定时器)</a>。</p></li>
            <li><p>该线程处于非调试调优阶段。</p></li>
            <li><p>该线程中不存在已创建未销毁的子Worker。</p></li>
        </ul>
    </div>
</div>
<div></div>
</body>
</html>"